循环队列实现杨辉三角及数据结构

最新推荐文章于 2024-03-21 15:13:16 发布
最新推荐文章于 2024-03-21 15:13:16 发布
阅读量9.7k 收藏 31
点赞数 6
分类专栏： c C++ 数据结构 文章标签： 指针 数据结构 栈 存储 循环队列杨辉三角
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cherubim5/article/details/51234305
版权
C++ 同时被 3 个专栏收录
2 篇文章 0 订阅
订阅专栏
c
1 篇文章 0 订阅
订阅专栏
数据结构
1 篇文章 0 订阅
订阅专栏

数据结构顺序，链式实现栈和队列的相关操作，并用循环队列实现杨辉三角。

1．采用链式存储实现栈的初始化、入栈、出栈操作。
链式栈中首先确定栈底指针，再入栈，并移动栈顶指针。

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#define MAX 100       //栈，循环队列的最大值；
#define OVERFLOW -1

using namespace std;

typedef int ElemType;
typedef int Status;
typedef struct Stack   //顺序栈；
{ 
    ElemType *base;
    ElemType *top;
}SqStack;
typedef struct LNode    //链式栈的结点； 
{
    ElemType data;
    struct LNode *next;
};
typedef struct LqStack  //链式栈；
{
    struct LNode *base;
    struct LNode *top;
};
typedef struct Queue    //链式队列；
{
   struct LNode *rear;
   struct LNode *front;
}SqQueue;
typedef struct        //顺序队列
{  
    ElemType *base;
    int front;
    int rear;
}SqQueueCir;
typedef struct{   //杨辉三角特殊循环队列；

    ElemType *base;
    int front;
    int rear;
    int temp;          //记录上一行的rear，以确定出队的结束；
}SqQueueCirl;
void CreateLq(LqStack &s)   //链式栈的构建；
{
  s.top = (LNode*)malloc(sizeof(LNode));
  s.top->next = NULL;
}
void LqPush(LqStack &s)      //链式栈的入栈；
{
    LNode *p;
    cin>>s.top->data;
    p = (LNode*)malloc(sizeof(LNode));
    p->next = s.top;  //....
    s.top = p;
}
ElemType LqGetTop(LqStack s)
//链式栈的出栈，返回一个ElemT类型；数，并释放此结点。
{
    LNode *p;
    ElemType e;
    p = s.top->next;
    e = p->data;
    s.top->next= p->next;
    free(p);
    return e;
}

2．采用顺序存储实现栈的初始化、入栈、出栈操作。
顺序栈类似于数组，栈底指针为0号元素，


void CreateSq(SqStack &s)        //顺序栈初始化;
{
    s.base = (ElemType * )malloc(MAX*sizeof(ElemType));
    if(!s.base)
     exit(OVERFLOW);
    s.top = s.base;
}
void Push(SqStack &s,ElemType e)   //顺序栈入栈;
{
    if((s.top-s.base)>MAX||(s.top-s.base)==MAX)
      exit(OVERFLOW);
     *(s.top) = e;
     s.top++;
}
ElemType GetTop(SqStack &s)       //顺序栈出栈;
{
    ElemType e;
    if(s.top == s.base)//判断栈空;
    cout<<"栈为空！"<<endl;
    e = *(s.top-1);
    s.top--;
    return e;
}

3．采用链式存储实现队列的初始化、入队、出队操作。

void InitQueue(SqQueue &Q)      //链式队列的初始化;
{
    Q.rear=(LNode*)malloc(sizeof(LNode));
    if(!Q.rear)exit(OVERFLOW);//判断是否成功开辟空间;
     Q.front = Q.rear;
    Q.front->next = NULL;
}
void EnQueue(SqQueue &Q)   //链式队列的入队;
{
    LNode *p;
    p = (LNode*)malloc(sizeof(LNode));
    if(!p)exit(OVERFLOW);
    cin>>p->data;
    p->next = NULL;
    Q.rear->next = p;
    Q.rear = p;
}
ElemType PoQueue(SqQueue &Q)//链式队列的出队;
{
    LNode *p;
    ElemType e;
    if(Q.rear ==Q.front)exit(OVERFLOW);
    p = Q.front->next;
    e = p->data;
    Q.front->next = p->next;
    if(Q.rear == p) Q.rear = Q.front;
    free(p);
    return e;
}

4．采用顺序存储实现循环队列的初始化、入队、出队操作。

void Create_Sq(SqQueueCir &q)
{
    q.base = (ElemType*)malloc(MAX * sizeof(ElemType));
    if(!q.base)exit(OVERFLOW);
    q.front = q.rear =0;
}
void InitQueue_Sq(SqQueueCir &q)//入队
{
    if((q.rear+1)%MAX==q.front)exit(OVERFLOW);
    cin>>q.base[q.rear];
    q.rear = (q.rear+1)%MAX;
}
ElemType DeQueue_Sq(SqQueueCir &q)
{
    if(q.front==q.rear)exit(OVERFLOW);
    ElemType e = q.base[q.front];
    q.front = (q.front+1)%MAX;
    return e;
}

5．在主函数中设计一个简单的菜单，分别测试上述算法。

void Menu()
{printf("按数字键选择相应操作\n");
 printf("<1> 采用链式存储实现栈的初始化、入栈、出栈操作:\n");
 printf("<2> 采用顺序存储实现栈的初始化、入栈、出栈操作:\n");
 printf("<3> 采用链式存储实现队列的初始化、入队、出队操作\n");
 printf("<4> 采用顺序存储实现循环队列的初始化、入队、出队操作:\n");
 printf("<5> 利用栈实现数制转换（将一个十进制数转换成d进制数）:\n");
 printf("<6> 利用队列打印8行杨辉三角：编写程序，根据输入的行数，屏幕显示8行杨辉三角:\n");
 printf("<0> 退出:\n");
}

6. 利用栈实现数制转换（将一个十进制数转换成d进制数）

void conversion()
{
    SqStack s;
    CreateSq(s);
    cout<<"请输入需转换进制元素：";
    ElemType e,n;
    cin>>e;
    cout<<"请输入转换成多少进制的权：";
    cin>>n;
    while(e)
    {
      Push(s,e%n);
      e=e/n;
    }
    while(s.base != s.top)
    {
        cout<<GetTop(s);
    }
    cout<<"("<<n<<")";
    cout<<endl;
}

7. 利用循环队列打印杨辉三角：编写程序，根据输入的行数，屏幕显示杨辉三角。
由于使用循环队列，所以只打印前八行的杨辉三角。

void Create(SqQueueCirl &q)
{
    q.base = (ElemType*)malloc(10*sizeof(ElemType));
   if(!q.base)exit(OVERFLOW);
   q.base[0] = 0;
   q.base[1] = 1; //循环队列的第一个元素存为1;
   q.temp = q.rear = 2;//对头和输出指针指向第二个元素的位置;
   q.front = 1;
}
void Init(SqQueueCirl &q)
{
    if((q.rear+1)%10==q.front)
    {cout<<"队列满";
     exit(OVERFLOW);
    }
     q.base[q.rear] = q.base[(q.front+9)%10]+q.base[q.front];
     q.rear = (q.rear+1)%10;
}
ElemType DeQueue_Sq(SqQueueCirl &q)
{
    if(q.front==q.rear)exit(OVERFLOW);
    ElemType e = q.base[q.front];
    q.front = (q.front+1)%10;
    return e;
}
void PascalTriangle()
{
    SqQueueCirl q;
    Create(q);
    int i = 8,k=14;
    while(i--)
    {   while(k--)
        cout<<" ";
        while(q.front!=q.temp)
         {
              Init(q);
            cout<<DeQueue_Sq(q)<< "   ";
         }//输出上一行的i时，存入下一行的元素;
         q.base[(q.temp+9)%10] = 0;
         cout<<endl;
         q.base[q.rear] = 1;
         q.rear = (q.rear+1)%10;
         q.temp = q.rear;
        k = (i-1)*2;
    }
}

主函数

int main()
{
     int m,e,n;
     while(1)
    {
        Menu();
       cin >>n;
     switch(n)
     {
         case 1:
            cout<<"请输入需入栈元素个数：";
            LqStack head;
            CreateLq(head);
            cin>>m;
            cout<<"请依次输入"<<m<<"个数："<<endl;
            while(m--)
                LqPush(head);
            cout<<"入栈完成！"<<endl;
            while(head.top->next!=NULL)
            {
                cout<<LqGetTop(head)<<"  ";
            }
            cout<<endl;
            cout<<"出栈完成！"<<endl;
            break;
         case 2:
            cout<<"请输入需入栈元素个数：";
            SqStack s;
            CreateSq(s);
            cin>>m;
            cout<<"请依次输入"<<m<<"个数："<<endl;
            while(m--)
            {
                cin>>e;
                Push(s,e);
            }
            cout<<"入栈完成！"<<endl;
            while(s.base != s.top)
            {
                cout<<GetTop(s)<<"  ";
            }
            cout<<endl;
            cout<<"出栈完成！"<<endl;
            break;
        case 3:
            cout<<"请输入需入队元素个数：";
            SqQueue Q;
            InitQueue(Q);
            cin>>m;
            cout<<"请依次输入"<<m<<"个数："<<endl;
            while(m--)
                 EnQueue(Q);
            cout<<"入队完成！"<<endl;
            while(Q.front!=Q.rear)
            {
                cout<<PoQueue(Q)<<"  ";
            }
            cout<<endl;
            cout<<"出队完成！"<<endl;
            break;
        case 4:
            cout<<"请输入需入队元素个数：";
            SqQueueCir h;
            Create_Sq(h);
            cin>>m;
            cout<<"请依次输入"<<m<<"个数："<<endl;
            while(m--)
                 InitQueue_Sq(h);
            cout<<"入队完成！"<<endl;
            while(h.front!=h.rear)
            {
                cout<<DeQueue_Sq(h)<<"  ";
            }
            cout<<endl;
            cout<<"出队完成！"<<endl;
            break;

        case 5:
            conversion();
            break;

        case 6:
            PascalTriangle();
            break;

        case 0:
            exit(OVERFLOW);
        default:
            cout<<"输入错误，请重新输入："<<endl;
            break;
        }
    }
    return 0;
}
cherubim5
关注
  • 6
    点赞
  • 踩
  • 31
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
循环队列实现杨辉三角
11-18
该C程序使用循环队列实现了N行杨辉三角的输出，实现简单。 使用VC进行编译即可。
循环队列实现杨辉三角的输出
10-17
用循环队列实现杨辉三角的输出。通过该程序可以让你对循环队列有一定的理解。
奇偶排序（Odd-Even Sort）
最新发布
qq_55880505的博客
03-21 376
奇偶排序
使用队列循环实现杨辉三角
aoyi8281的博客
10-21 325
杨辉三角的简单定义：杨辉三角，是二项式系数在三角形中的一种几何排列。 杨辉三角的简单性质：每个数等于它上方两数之和。 每行数字左右对称，由1开始逐渐变大。 第n行的数字有n项。 第n行数字和为2n-1。 第n行的m个数可表示为 C(n-1，m-1)，即为从n-1个不同元素中取m-1个元素的组合数。 第n行的第m个数和第n-m+1个数相等 ，为组合数性质之一。 每个数字等于上一行的左右两个...
SWUST OJ 966：打印杨辉三角形（C语言 循环队列实现）
weixin_45380689的博客
03-26 2811
据说数据结构考试必须用学的这些数据结构，所以就老老实实写了，没有用规律，STL容器之类的，博主的码风太丑，不喜勿喷 题目描述 杨辉三角形具有如下特征：1、每行数字左右对称，由1开始逐渐变大，然后变小，回到1。 2、第n行的数字个数为n个。 3、第n行数字和为2^(n－1)。 4、每个数字等于上一行的左右两个数字之和。可用此性质写出整个帕斯卡三角形。 5、将第2n+1行第1个数，跟第2n+2行第3......
c++用结构体结合循环队列来实现杨辉三角形
qq_44247658的博客
05-14 1111
杨辉三角，是二项式系数在三角形中的一种几何排列。在欧洲，这个表叫做帕斯卡三角形。帕斯卡是在1654年发现这一规律的，比杨辉要迟393年，比贾宪迟600年。杨辉三角是中国古代数学的杰出研究成果之一，它把二项式系数图形化，把组合数内在的一些代数性质直观地从图形中体现出来，是一种离散型的数与形的结合。 杨辉三角的特点： 1.每个数等于它上方两数之和。 2.每行数字左右对称，由1开始逐渐变大。 3.第n行的数字有n项。 。 例如： 这里我们用c++的结构体和循环队列来进行编译： 定义结构体： typedef st
用循环队列获得杨辉三角
time
02-22 519
中国古代数学史曾经有代写论文自己光辉灿烂的篇章，而杨辉三角的发现就是十分精彩的一页。杨辉三角是中国古代数学家贾宪在公元11世纪发现，并被南宋数学家杨辉在他的书中所引述，才使我们今天得以了解贾宪在数学上的重大贡献。杨辉三角是一个由数字排列成的三角形数表.一般形式如下: 1 1 1 1 2 ...
队列实现杨辉三角（附详细图解）
热门推荐
就爱摆烂
04-15 1万+
之前我已经写了两篇关于队列的基本功能，今天我们使用循环顺序队来实现输出杨辉三角。 这是我们最终想要的效果：* 目录算法思路代码实现思考总结 算法思路 这里我将使用图示法配合文字。 代码实现 关于代码，这里只展示核心部分。 其他关于入栈，出栈，初始化的操作请移步我之前的文章。 附上链接： 顺序队与链队（一） #include"SqQueue.h" void test() { SQ s; s.SQInit(); //杨辉三角的过程 int line = 7;//杨辉三角的行数 int val
循环队列实现杨辉三角（两种输出形式）
tan-1210的博客
03-30 1万+
问题导入什么是杨辉三角呢？之前用过C/C++数组实现过打印杨辉三角，那么如何使用队列来实现呢？
数据结构——栈和队列 02（杨辉三角队列解法）
herui7322的博客
01-25 2825
队列处理模式： 整个数据处理过程模型即是一个队列的形式。 杨辉三角的队列解法，编程输出几行杨辉三角形； 【】杨辉三角是由二项式（a+b）的 n 次方（n=1,2,3…）展开后各项的系数排成的三角形，它的特点是左右两边全是1，从第二行起，中间的每一个数是上一行里相邻两个数之和。 算法描述： 在每行之间插入一个0作为行的分隔标记，形成的系数序列存在数组queue[]中。 设 front 指向要求和的...
【数据结构】栈——杨辉三角问题
jxyyyy的博客
03-26 1490
#include<stdio.h> #include<string.h> #include<malloc.h> #define error 1 #define ok 0 typedef int elem; typedef int status; typedef struct qnode { elem data; struct qnode *next; }qnode,*queueptr; typedef struct { queueptr front
数据结构——基于C语言实现杨辉三角
08-11
（1）始化一个空在循环队列 (2)循环队列入队操作 (3)循环队列出队操作 (4)取出头指针 (5)main 函数
数据结构实训 打印杨辉三角
05-23
循环队列的相关应用，利用循环队列打印杨辉三角形
数据结构C++ 顺序栈、链栈、循环队列、链队列的主要操作（Word文档含代码和注释）
11-04
注：分为四个内容：顺序栈、链栈、循环队列、链队列。代码由C++程序设计语言编写，包含栈和队列的基本操作（栈：出、入、取、判空等|队列：出、入、取、打印队列、判空等），并展示了三个具体的使用例子，包括用栈求...
数据结构——队列的应用.doc
07-11
软 件 学 院 上 机 实 验 报 告 课程名称： 数据结构 实验项目： 队列的应用 实 验 室... 利用循环队列实现杨辉三角的输出 " "(二).步骤 " "1.//---------循环队列—队列的顺序存储结构 ----- " "#define MAXSIZE 100
数据结构及算法C语言实现代码集[推荐下载]
11-10
数据结构 数组 文件程序 求进制 汉诺塔 硬币情况 逆阵 链串.c 链栈.c 链队列.c 问题算法 顺序栈.c 顺序表.c 顺序队列.c ./其它: c语言窗体实例.zip 傻瓜递归.c 冒泡法改进.c 小字库DIY-.c 小字库DIY.c 小白鼠钻...
（数据结构）循环队列打印杨辉三角（课后作业）
2301_79580018的博客
10-30 760
【代码】（数据结构）循环队列打印杨辉三角。
数据结构和c语言的名词解析
一个只会写bug的搬运工
04-07 2707
C语言的名词解析 第一章 c语言基础 1.编译 计算机语言：机器语言、低级语言（汇编语言）、高级语言 机器语言是：机器语言是机器能直接识别的程序语言或指令代码，无需经过翻译，每一操作码在计算机内部都有相应的电路来完成它，或指不经翻译即可为机器直接理解和接受的程序语言或指令代码。 高级语言是一种面向对象或者面向过程的语言，Java、c、c++、python都是高级语言 2.关于c语言在各阶段的产物 经历了编辑、编译、链接 1.编辑：编写代码，制作C语言的源文件。（源程序，后缀是.c） 2.编译：
数据结构实验3.2 借助栈实现数制转换&借助队列实现杨辉三角
一半西瓜的博客
10-11 696
赞赏码 & 联系方式 & 个人闲话 附加题 1. 借助栈实现数制转换。要求将非负十进制整数N转换为二进制输出。具体实现参考教材。 #include<stdio.h> #include<stdlib.h> #define ok 1 #define error 0 #define overflow 0 typedef struct stacknode {...
循环队列实现杨辉三角C语言数据结构
06-10
以下是使用C语言实现循环队列生成杨辉三角的代码： ```c #include <stdio.h> #include <stdlib.h> #define MAX_SIZE 100 // 定义循环队列 typedef struct { int front; // 队首指针 int rear; // 队尾指针 int items[MAX_SIZE]; // 队列元素 } Queue; // 初始化队列 void init_queue(Queue *q) { q->front = q->rear = 0; } // 判断队列是否为空 int is_empty(Queue *q) { return q->front == q->rear; } // 判断队列是否已满 int is_full(Queue *q) { return (q->rear + 1) % MAX_SIZE == q->front; } // 元素入队 void enqueue(Queue *q, int item) { if (!is_full(q)) { q->items[q->rear] = item; q->rear = (q->rear + 1) % MAX_SIZE; } } // 元素出队 int dequeue(Queue *q) { if (!is_empty(q)) { int item = q->items[q->front]; q->front = (q->front + 1) % MAX_SIZE; return item; } return -1; } // 生成杨辉三角 void generate_yanghui_triangle(int n) { Queue q; init_queue(&q); enqueue(&q, 1); // 第一行只有一个数字1 for (int i = 0; i < n; i++) { for (int j = 0; j <= i; j++) { printf("%d ", q.items[j]); } printf("\n"); for (int j = 0; j <= i; j++) { enqueue(&q, dequeue(&q) + q.items[j]); } enqueue(&q, 1); // 行末添加数字1 } } int main() { generate_yanghui_triangle(5); // 生成5行杨辉三角 return 0; } ``` 代码中定义了一个循环队列结构体Queue，包含front、rear和items三个成员变量。init_queue函数用于初始化队列，is_empty和is_full函数用于判断队列是否为空和已满，enqueue和dequeue函数实现元素的入队和出队操作。generate_yanghui_triangle函数使用队列来生成杨辉三角，通过两个for循环遍历队列中的数字并输出，将队首出队并加上队列中的每个数字，将结果入队，最后再将数字1入队。重复这个过程，就可以生成指定行数的杨辉三角。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值